home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / scripts / recordmcount.pl < prev    next >
Encoding:
Perl Script  |  2008-12-24  |  10.9 KB  |  416 lines
  1. #!/usr/bin/perl -w
  2. # (c) 2008, Steven Rostedt <srostedt@redhat.com>
  3. # Licensed under the terms of the GNU GPL License version 2
  4. #
  5. # recordmcount.pl - makes a section called __mcount_loc that holds
  6. #                   all the offsets to the calls to mcount.
  7. #
  8. #
  9. # What we want to end up with is a section in vmlinux called
  10. # __mcount_loc that contains a list of pointers to all the
  11. # call sites in the kernel that call mcount. Later on boot up, the kernel
  12. # will read this list, save the locations and turn them into nops.
  13. # When tracing or profiling is later enabled, these locations will then
  14. # be converted back to pointers to some function.
  15. #
  16. # This is no easy feat. This script is called just after the original
  17. # object is compiled and before it is linked.
  18. #
  19. # The references to the call sites are offsets from the section of text
  20. # that the call site is in. Hence, all functions in a section that
  21. # has a call site to mcount, will have the offset from the beginning of
  22. # the section and not the beginning of the function.
  23. #
  24. # The trick is to find a way to record the beginning of the section.
  25. # The way we do this is to look at the first function in the section
  26. # which will also be the location of that section after final link.
  27. # e.g.
  28. #
  29. #  .section ".text.sched"
  30. #  .globl my_func
  31. #  my_func:
  32. #        [...]
  33. #        call mcount  (offset: 0x5)
  34. #        [...]
  35. #        ret
  36. #  other_func:
  37. #        [...]
  38. #        call mcount (offset: 0x1b)
  39. #        [...]
  40. #
  41. # Both relocation offsets for the mcounts in the above example will be
  42. # offset from .text.sched. If we make another file called tmp.s with:
  43. #
  44. #  .section __mcount_loc
  45. #  .quad  my_func + 0x5
  46. #  .quad  my_func + 0x1b
  47. #
  48. # We can then compile this tmp.s into tmp.o, and link it to the original
  49. # object.
  50. #
  51. # But this gets hard if my_func is not globl (a static function).
  52. # In such a case we have:
  53. #
  54. #  .section ".text.sched"
  55. #  my_func:
  56. #        [...]
  57. #        call mcount  (offset: 0x5)
  58. #        [...]
  59. #        ret
  60. #  .globl my_func
  61. #  other_func:
  62. #        [...]
  63. #        call mcount (offset: 0x1b)
  64. #        [...]
  65. #
  66. # If we make the tmp.s the same as above, when we link together with
  67. # the original object, we will end up with two symbols for my_func:
  68. # one local, one global.  After final compile, we will end up with
  69. # an undefined reference to my_func.
  70. #
  71. # Since local objects can reference local variables, we need to find
  72. # a way to make tmp.o reference the local objects of the original object
  73. # file after it is linked together. To do this, we convert the my_func
  74. # into a global symbol before linking tmp.o. Then after we link tmp.o
  75. # we will only have a single symbol for my_func that is global.
  76. # We can convert my_func back into a local symbol and we are done.
  77. #
  78. # Here are the steps we take:
  79. #
  80. # 1) Record all the local symbols by using 'nm'
  81. # 2) Use objdump to find all the call site offsets and sections for
  82. #    mcount.
  83. # 3) Compile the list into its own object.
  84. # 4) Do we have to deal with local functions? If not, go to step 8.
  85. # 5) Make an object that converts these local functions to global symbols
  86. #    with objcopy.
  87. # 6) Link together this new object with the list object.
  88. # 7) Convert the local functions back to local symbols and rename
  89. #    the result as the original object.
  90. #    End.
  91. # 8) Link the object with the list object.
  92. # 9) Move the result back to the original object.
  93. #    End.
  94. #
  95.  
  96. use strict;
  97.  
  98. my $P = $0;
  99. $P =~ s@.*/@@g;
  100.  
  101. my $V = '0.1';
  102.  
  103. if ($#ARGV < 6) {
  104.     print "usage: $P arch objdump objcopy cc ld nm rm mv inputfile\n";
  105.     print "version: $V\n";
  106.     exit(1);
  107. }
  108.  
  109. my ($arch, $bits, $objdump, $objcopy, $cc,
  110.     $ld, $nm, $rm, $mv, $inputfile) = @ARGV;
  111.  
  112. # Acceptable sections to record.
  113. my %text_sections = (
  114.      ".text" => 1,
  115. );
  116.  
  117. $objdump = "objdump" if ((length $objdump) == 0);
  118. $objcopy = "objcopy" if ((length $objcopy) == 0);
  119. $cc = "gcc" if ((length $cc) == 0);
  120. $ld = "ld" if ((length $ld) == 0);
  121. $nm = "nm" if ((length $nm) == 0);
  122. $rm = "rm" if ((length $rm) == 0);
  123. $mv = "mv" if ((length $mv) == 0);
  124.  
  125. #print STDERR "running: $P '$arch' '$objdump' '$objcopy' '$cc' '$ld' " .
  126. #    "'$nm' '$rm' '$mv' '$inputfile'\n";
  127.  
  128. my %locals;        # List of local (static) functions
  129. my %weak;        # List of weak functions
  130. my %convert;        # List of local functions used that needs conversion
  131.  
  132. my $type;
  133. my $section_regex;    # Find the start of a section
  134. my $function_regex;    # Find the name of a function
  135.             #    (return offset and func name)
  136. my $mcount_regex;    # Find the call site to mcount (return offset)
  137.  
  138. if ($arch eq "x86") {
  139.     if ($bits == 64) {
  140.     $arch = "x86_64";
  141.     } else {
  142.     $arch = "i386";
  143.     }
  144. }
  145.  
  146. if ($arch eq "x86_64") {
  147.     $section_regex = "Disassembly of section\\s+(\\S+):";
  148.     $function_regex = "^([0-9a-fA-F]+)\\s+<(.*?)>:";
  149.     $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\smcount([+-]0x[0-9a-zA-Z]+)?\$";
  150.     $type = ".quad";
  151.  
  152.     # force flags for this arch
  153.     $ld .= " -m elf_x86_64";
  154.     $objdump .= " -M x86-64";
  155.     $objcopy .= " -O elf64-x86-64";
  156.     $cc .= " -m64";
  157.  
  158. } elsif ($arch eq "i386") {
  159.     $section_regex = "Disassembly of section\\s+(\\S+):";
  160.     $function_regex = "^([0-9a-fA-F]+)\\s+<(.*?)>:";
  161.     $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\smcount\$";
  162.     $type = ".long";
  163.  
  164.     # force flags for this arch
  165.     $ld .= " -m elf_i386";
  166.     $objdump .= " -M i386";
  167.     $objcopy .= " -O elf32-i386";
  168.     $cc .= " -m32";
  169.  
  170. } else {
  171.     die "Arch $arch is not supported with CONFIG_FTRACE_MCOUNT_RECORD";
  172. }
  173.  
  174. my $text_found = 0;
  175. my $read_function = 0;
  176. my $opened = 0;
  177. my $mcount_section = "__mcount_loc";
  178.  
  179. my $dirname;
  180. my $filename;
  181. my $prefix;
  182. my $ext;
  183.  
  184. if ($inputfile =~ m,^(.*)/([^/]*)$,) {
  185.     $dirname = $1;
  186.     $filename = $2;
  187. } else {
  188.     $dirname = ".";
  189.     $filename = $inputfile;
  190. }
  191.  
  192. if ($filename =~ m,^(.*)(\.\S),) {
  193.     $prefix = $1;
  194.     $ext = $2;
  195. } else {
  196.     $prefix = $filename;
  197.     $ext = "";
  198. }
  199.  
  200. my $mcount_s = $dirname . "/.tmp_mc_" . $prefix . ".s";
  201. my $mcount_o = $dirname . "/.tmp_mc_" . $prefix . ".o";
  202.  
  203. #
  204. # --globalize-symbols came out in 2.17, we must test the version
  205. # of objcopy, and if it is less than 2.17, then we can not
  206. # record local functions.
  207. my $use_locals = 01;
  208. my $local_warn_once = 0;
  209. my $found_version = 0;
  210.  
  211. open (IN, "$objcopy --version |") || die "error running $objcopy";
  212. while (<IN>) {
  213.     if (/objcopy.*\s(\d+)\.(\d+)/) {
  214.     my $major = $1;
  215.     my $minor = $2;
  216.  
  217.     $found_version = 1;
  218.     if ($major < 2 ||
  219.         ($major == 2 && $minor < 17)) {
  220.         $use_locals = 0;
  221.     }
  222.     last;
  223.     }
  224. }
  225. close (IN);
  226.  
  227. if (!$found_version) {
  228.     print STDERR "WARNING: could not find objcopy version.\n" .
  229.     "\tDisabling local function references.\n";
  230. }
  231.  
  232.  
  233. #
  234. # Step 1: find all the local (static functions) and weak symbols.
  235. #        't' is local, 'w/W' is weak (we never use a weak function)
  236. #
  237. open (IN, "$nm $inputfile|") || die "error running $nm";
  238. while (<IN>) {
  239.     if (/^[0-9a-fA-F]+\s+t\s+(\S+)/) {
  240.     $locals{$1} = 1;
  241.     } elsif (/^[0-9a-fA-F]+\s+([wW])\s+(\S+)/) {
  242.     $weak{$2} = $1;
  243.     }
  244. }
  245. close(IN);
  246.  
  247. my @offsets;        # Array of offsets of mcount callers
  248. my $ref_func;        # reference function to use for offsets
  249. my $offset = 0;        # offset of ref_func to section beginning
  250.  
  251. ##
  252. # update_funcs - print out the current mcount callers
  253. #
  254. #  Go through the list of offsets to callers and write them to
  255. #  the output file in a format that can be read by an assembler.
  256. #
  257. sub update_funcs
  258. {
  259.     return if ($#offsets < 0);
  260.  
  261.     defined($ref_func) || die "No function to reference";
  262.  
  263.     # A section only had a weak function, to represent it.
  264.     # Unfortunately, a weak function may be overwritten by another
  265.     # function of the same name, making all these offsets incorrect.
  266.     # To be safe, we simply print a warning and bail.
  267.     if (defined $weak{$ref_func}) {
  268.     print STDERR
  269.         "$inputfile: WARNING: referencing weak function" .
  270.         " $ref_func for mcount\n";
  271.     return;
  272.     }
  273.  
  274.     # is this function static? If so, note this fact.
  275.     if (defined $locals{$ref_func}) {
  276.  
  277.     # only use locals if objcopy supports globalize-symbols
  278.     if (!$use_locals) {
  279.         return;
  280.     }
  281.     $convert{$ref_func} = 1;
  282.     }
  283.  
  284.     # Loop through all the mcount caller offsets and print a reference
  285.     # to the caller based from the ref_func.
  286.     for (my $i=0; $i <= $#offsets; $i++) {
  287.     if (!$opened) {
  288.         open(FILE, ">$mcount_s") || die "can't create $mcount_s\n";
  289.         $opened = 1;
  290.         print FILE "\t.section $mcount_section,\"a\",\@progbits\n";
  291.     }
  292.     printf FILE "\t%s %s + %d\n", $type, $ref_func, $offsets[$i] - $offset;
  293.     }
  294. }
  295.  
  296. #
  297. # Step 2: find the sections and mcount call sites
  298. #
  299. open(IN, "$objdump -dr $inputfile|") || die "error running $objdump";
  300.  
  301. my $text;
  302.  
  303. while (<IN>) {
  304.     # is it a section?
  305.     if (/$section_regex/) {
  306.  
  307.     # Only record text sections that we know are safe
  308.     if (defined($text_sections{$1})) {
  309.         $read_function = 1;
  310.     } else {
  311.         $read_function = 0;
  312.     }
  313.     # print out any recorded offsets
  314.     update_funcs() if ($text_found);
  315.  
  316.     # reset all markers and arrays
  317.     $text_found = 0;
  318.     undef($ref_func);
  319.     undef(@offsets);
  320.  
  321.     # section found, now is this a start of a function?
  322.     } elsif ($read_function && /$function_regex/) {
  323.     $text_found = 1;
  324.     $offset = hex $1;
  325.     $text = $2;
  326.  
  327.     # if this is either a local function or a weak function
  328.     # keep looking for functions that are global that
  329.     # we can use safely.
  330.     if (!defined($locals{$text}) && !defined($weak{$text})) {
  331.         $ref_func = $text;
  332.         $read_function = 0;
  333.     } else {
  334.         # if we already have a function, and this is weak, skip it
  335.         if (!defined($ref_func) || !defined($weak{$text})) {
  336.         $ref_func = $text;
  337.         }
  338.     }
  339.     }
  340.  
  341.     # is this a call site to mcount? If so, record it to print later
  342.     if ($text_found && /$mcount_regex/) {
  343.     $offsets[$#offsets + 1] = hex $1;
  344.     }
  345. }
  346.  
  347. # dump out anymore offsets that may have been found
  348. update_funcs() if ($text_found);
  349.  
  350. # If we did not find any mcount callers, we are done (do nothing).
  351. if (!$opened) {
  352.     exit(0);
  353. }
  354.  
  355. close(FILE);
  356.  
  357. #
  358. # Step 3: Compile the file that holds the list of call sites to mcount.
  359. #
  360. `$cc -o $mcount_o -c $mcount_s`;
  361.  
  362. my @converts = keys %convert;
  363.  
  364. #
  365. # Step 4: Do we have sections that started with local functions?
  366. #
  367. if ($#converts >= 0) {
  368.     my $globallist = "";
  369.     my $locallist = "";
  370.  
  371.     foreach my $con (@converts) {
  372.     $globallist .= " --globalize-symbol $con";
  373.     $locallist .= " --localize-symbol $con";
  374.     }
  375.  
  376.     my $globalobj = $dirname . "/.tmp_gl_" . $filename;
  377.     my $globalmix = $dirname . "/.tmp_mx_" . $filename;
  378.  
  379.     #
  380.     # Step 5: set up each local function as a global
  381.     #
  382.     `$objcopy $globallist $inputfile $globalobj`;
  383.  
  384.     #
  385.     # Step 6: Link the global version to our list.
  386.     #
  387.     `$ld -r $globalobj $mcount_o -o $globalmix`;
  388.  
  389.     #
  390.     # Step 7: Convert the local functions back into local symbols
  391.     #
  392.     `$objcopy $locallist $globalmix $inputfile`;
  393.  
  394.     # Remove the temp files
  395.     `$rm $globalobj $globalmix`;
  396.  
  397. } else {
  398.  
  399.     my $mix = $dirname . "/.tmp_mx_" . $filename;
  400.  
  401.     #
  402.     # Step 8: Link the object with our list of call sites object.
  403.     #
  404.     `$ld -r $inputfile $mcount_o -o $mix`;
  405.  
  406.     #
  407.     # Step 9: Move the result back to the original object.
  408.     #
  409.     `$mv $mix $inputfile`;
  410. }
  411.  
  412. # Clean up the temp files
  413. `$rm $mcount_o $mcount_s`;
  414.  
  415. exit(0);
  416.